home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / term-source.lha / HotkeyPanel.c < prev    next >
C/C++ Source or Header  |  1995-09-28  |  15KB  |  693 lines
  1. /*
  2. **    HotkeyPanel.c
  3. **
  4. **    Editing panel for hotkey configuration
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_TERMTOFRONT=1,GAD_BUFFERTOFRONT,GAD_SKIPDIAL,GAD_ABORTAREXX,
  13.         GAD_PRIORITY,GAD_HOTKEYS,GAD_USE,GAD_LOAD,GAD_SAVE,GAD_CANCEL
  14.     };
  15.  
  16. struct Library *KeymapBase;
  17.  
  18.     // All the rawkey codes we know about
  19.  
  20. #define RAWKEY_CURSOR_UP    76
  21. #define RAWKEY_CURSOR_DOWN    77
  22. #define RAWKEY_CURSOR_RIGHT    78
  23. #define RAWKEY_CURSOR_LEFT    79
  24.  
  25. #define RAWKEY_F1        80
  26. #define RAWKEY_F2        81
  27. #define RAWKEY_F3        82
  28. #define RAWKEY_F4        83
  29. #define RAWKEY_F5        84
  30. #define RAWKEY_F6        85
  31. #define RAWKEY_F7        86
  32. #define RAWKEY_F8        87
  33. #define RAWKEY_F9        88
  34. #define RAWKEY_F10        89
  35.  
  36. #define RAWKEY_HELP        95
  37.  
  38. STATIC BOOLEAN __regargs
  39. GoodCode(STRPTR Code)
  40. {
  41.     IX Expression;
  42.  
  43.     return((BOOLEAN)(ParseIX(Code,&Expression) == 0));
  44. }
  45.  
  46.     /* EditRoutine():
  47.      *
  48.      *    A special string gadget editing routine for key
  49.      *    combination input.
  50.      */
  51.  
  52. ULONG __saveds __asm
  53. EditRoutine(register __a0 struct Hook *Hook,register __a2 struct SGWork *Work,register __a1 ULONG *Msg)
  54. {
  55.     struct InputEvent    Event;
  56.     ULONG            Qualifier;
  57.     UWORD            Code;
  58.     UBYTE            Key[10];
  59.     WORD            KeyLen;
  60.     STRPTR            KeyName;
  61.  
  62.         // If the gadget just got activated or the caps lock key
  63.         // is active, don't change anything
  64.  
  65.     if(*Msg == SGH_CLICK || (*Msg == SGH_KEY && (Work -> IEvent -> ie_Qualifier & IEQUALIFIER_CAPSLOCK)))
  66.         return(TRUE);
  67.     else
  68.     {
  69.             // Complain if this is not what we expect to be fun
  70.  
  71.         if(*Msg != SGH_KEY)
  72.             return(FALSE);
  73.     }
  74.  
  75.         // Ditch the qualifier keys
  76.  
  77.     if(Work -> IEvent -> ie_Code >= 96 && Work -> IEvent -> ie_Code <= 103)
  78.     {
  79.         Work -> Actions    &= ~(SGA_USE | SGA_BEEP);
  80.  
  81.         return(TRUE);
  82.     }
  83.  
  84.         // Strip all the qualifiers we don't want
  85.  
  86.     Qualifier = Work -> IEvent -> ie_Qualifier & ~(IEQUALIFIER_REPEAT | IEQUALIFIER_INTERRUPT | IEQUALIFIER_MULTIBROADCAST | IEQUALIFIER_RELATIVEMOUSE);
  87.  
  88.         // Check for raw keys
  89.  
  90.     switch(Work -> IEvent -> ie_Code)
  91.     {
  92.         case RAWKEY_CURSOR_UP:
  93.         case RAWKEY_CURSOR_DOWN:
  94.         case RAWKEY_CURSOR_RIGHT:
  95.         case RAWKEY_CURSOR_LEFT:
  96.  
  97.                 // A cursor key was pressed, check if there
  98.                 // is probably some special feature involved
  99.  
  100.             if(!(Qualifier & ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
  101.                 return(TRUE);
  102.  
  103.             // FALLS THROUGH TO:
  104.  
  105.         case RAWKEY_F1:
  106.         case RAWKEY_F2:
  107.         case RAWKEY_F3:
  108.         case RAWKEY_F4:
  109.         case RAWKEY_F5:
  110.         case RAWKEY_F6:
  111.         case RAWKEY_F7:
  112.         case RAWKEY_F8:
  113.         case RAWKEY_F9:
  114.         case RAWKEY_F10:
  115.  
  116.         case RAWKEY_HELP:
  117.  
  118.                 // Ok, so this is a raw key event
  119.  
  120.             Code    = Work -> IEvent -> ie_Code;
  121.             KeyLen    = 0;
  122.  
  123.             break;
  124.  
  125.         default:
  126.  
  127.                 // Make a copy of the inputevent and
  128.                 // clear the qualifier bits
  129.  
  130.             CopyMem(Work -> IEvent,&Event,sizeof(struct InputEvent));
  131.  
  132.             Event . ie_Qualifier = NULL;
  133.  
  134.             Code = 0;
  135.  
  136.                 // Translate the event
  137.  
  138.             if((KeyLen = MapRawKey(&Event,Key,10,NULL)) < 0)
  139.                 KeyLen = 10;
  140.  
  141.             break;
  142.     }
  143.  
  144.         // Is the user holding down a single Amiga key?
  145.  
  146.     if(KeyLen && (Qualifier & IEQUALIFIER_RCOMMAND) && !(Qualifier & ~IEQUALIFIER_RCOMMAND))
  147.     {
  148.         UBYTE Char = ToUpper(Key[0]);
  149.  
  150.             // Undo and clear are supported
  151.  
  152.         if(Char == 'Q' || Char == 'X')
  153.             return(TRUE);
  154.     }
  155.  
  156.         // Can we safely continue?
  157.  
  158.     if((!Code && !KeyLen) || KeyLen > 1 || (!Code && KeyLen && !Key[0]))
  159.     {
  160.         Work -> Actions    = (Work -> Actions & ~SGA_USE) | SGA_BEEP;
  161.  
  162.         return(TRUE);
  163.     }
  164.  
  165.         // Take care of special characters
  166.  
  167.     if(KeyLen)
  168.     {
  169.         STATIC struct { UBYTE Code; STRPTR Name; } KeyTable[] =
  170.         {
  171.             '\r',    "Return",
  172.             '\b',    "Backspace",
  173.             '\033',    "Escape",
  174.             ' ',    "Spacebar",
  175.             ',',    "Comma",
  176.             '\177',    "Delete",
  177.             '\t',    "Tab",
  178.  
  179.             0
  180.         };
  181.  
  182.         BOOL GotIt = FALSE;
  183.         WORD i;
  184.  
  185.             // Carriage return was pressed
  186.  
  187.         if(Key[0] == '\r')
  188.         {
  189.                 // This probably ends input
  190.  
  191.             if(!Qualifier)
  192.             {
  193.                 Work -> Actions    = (Work -> Actions & ~SGA_BEEP) | SGA_USE | SGA_END;
  194.  
  195.                 return(TRUE);
  196.             }
  197.             else
  198.             {
  199.                     // Is this the enter key?
  200.  
  201.                 if(Qualifier & IEQUALIFIER_NUMERICPAD)
  202.                 {
  203.                     KeyName = "Enter";
  204.  
  205.                     Qualifier &= ~IEQUALIFIER_NUMERICPAD;
  206.  
  207.                     GotIt = TRUE;
  208.                 }
  209.             }
  210.         }
  211.  
  212.             // If this is just the tab key, pass it through cleanly
  213.  
  214.         if(Key[0] == '\t' && !(Qualifier & ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
  215.             return(TRUE);
  216.  
  217.             // Now check for special characters
  218.  
  219.         Key[0] = ToUpper(Key[0]);
  220.  
  221.         if(!GotIt)
  222.         {
  223.             for(i = 0 ; KeyTable[i] . Code ; i++)
  224.             {
  225.                 if(KeyTable[i] . Code == Key[0])
  226.                 {
  227.                     KeyName = KeyTable[i] . Name;
  228.  
  229.                     GotIt = TRUE;
  230.  
  231.                     break;
  232.                 }
  233.             }
  234.         }
  235.  
  236.             // If no special character is involved,
  237.             // use the vanilla character code
  238.  
  239.         if(!GotIt)
  240.         {
  241.             if((Key[0] > ' ' && Key[0] < 127) || Key[0] >= 160)
  242.             {
  243.                 Key[1] = 0;
  244.  
  245.                 KeyName = Key;
  246.             }
  247.             else
  248.             {
  249.                 Work -> Actions    = (Work -> Actions & ~SGA_USE) | SGA_BEEP;
  250.  
  251.                 return(TRUE);
  252.             }
  253.         }
  254.     }
  255.     else
  256.     {
  257.             // Special raw key code table
  258.  
  259.         STATIC struct { UWORD Code; STRPTR Name; } RawTable[] =
  260.         {
  261.             RAWKEY_CURSOR_UP,    "Cursor_Up",
  262.             RAWKEY_CURSOR_DOWN,    "Cursor_Down",
  263.             RAWKEY_CURSOR_RIGHT,    "Cursor_Right",
  264.             RAWKEY_CURSOR_LEFT,    "Cursor_Left",
  265.  
  266.             RAWKEY_F1,        "F1",
  267.             RAWKEY_F2,        "F2",
  268.             RAWKEY_F3,        "F3",
  269.             RAWKEY_F4,        "F4",
  270.             RAWKEY_F5,        "F5",
  271.             RAWKEY_F6,        "F6",
  272.             RAWKEY_F7,        "F7",
  273.             RAWKEY_F8,        "F8",
  274.             RAWKEY_F9,        "F9",
  275.             RAWKEY_F10,        "F10",
  276.  
  277.             RAWKEY_HELP,        "Help",
  278.  
  279.             0
  280.         };
  281.  
  282.         WORD i;
  283.  
  284.             // One eventually must match
  285.  
  286.         for(i = 0 ; RawTable[i] . Code ; i++)
  287.         {
  288.             if(Code == RawTable[i] . Code)
  289.             {
  290.                 KeyName = RawTable[i] . Name;
  291.  
  292.                 break;
  293.             }
  294.         }
  295.     }
  296.  
  297.         // Take care of the qualifiers. Note that we do not distinguish
  298.         // between the left and right shift/alt keys
  299.  
  300.     if(Qualifier)
  301.     {
  302.         STATIC struct { ULONG Qualifier; STRPTR Name; } QualifierTable[] =
  303.         {
  304.             IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT,    "Shift ",
  305.             IEQUALIFIER_LALT | IEQUALIFIER_RALT,        "Alt ",
  306.             IEQUALIFIER_LCOMMAND,                "LAmiga ",
  307.             IEQUALIFIER_RCOMMAND,                "RAmiga ",
  308.             IEQUALIFIER_LEFTBUTTON,                "Left_Button ",
  309.             IEQUALIFIER_MIDBUTTON,                "Middle_Button ",
  310.             IEQUALIFIER_RBUTTON,                "Right_Button ",
  311.             IEQUALIFIER_NUMERICPAD,                "Numeric_Pad ",
  312.  
  313.             0
  314.         };
  315.  
  316.         WORD i;
  317.  
  318.             // Ok, now start building the string
  319.  
  320.         Work -> WorkBuffer[0] = 0;
  321.  
  322.         for(i = 0 ; QualifierTable[i] . Qualifier ; i++)
  323.         {
  324.             if(Qualifier & QualifierTable[i] . Qualifier)
  325.                 strcat(Work -> WorkBuffer,QualifierTable[i] . Name);
  326.         }
  327.  
  328.             // Add the key itself
  329.  
  330.         strcat(Work -> WorkBuffer,KeyName);
  331.  
  332.             // Update the work data
  333.  
  334.         Work -> NumChars    = strlen(Work -> WorkBuffer);
  335.         Work -> BufferPos    = Work -> NumChars;
  336.  
  337.             // Finished...
  338.  
  339.         Work -> Actions    = (Work -> Actions & ~(SGA_BEEP | SGA_PREVACTIVE | SGA_NEXTACTIVE | SGA_END)) | SGA_REDISPLAY | SGA_USE;
  340.     }
  341.     else
  342.         Work -> Actions    &= ~(SGA_USE | SGA_BEEP);
  343.  
  344.     return(TRUE);
  345. }
  346.  
  347. BYTE __regargs
  348. HotkeyPanel(struct Hotkeys *Hotkeys,BYTE *ChangePtr)
  349. {
  350.     STATIC struct Hook EditHook = { {NULL}, (HOOKFUNC)EditRoutine };
  351.  
  352.     struct LayoutHandle    *Handle;
  353.     struct Hotkeys         PrivateHotkeys;
  354.     ULONG             OldCRC;
  355.     BYTE             HotkeysChanged;
  356.  
  357.     KeymapBase = OpenLibrary("keymap.library",0);
  358.  
  359.     OldCRC = DoCRC(Hotkeys,sizeof(struct Hotkeys));
  360.  
  361.     CopyMem(Hotkeys,&PrivateHotkeys,sizeof(struct Hotkeys));
  362.  
  363.     if(ChangePtr)
  364.         HotkeysChanged = *ChangePtr;
  365.     else
  366.         HotkeysChanged = FALSE;
  367.  
  368.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  369.         LH_LocaleHook,    &LocaleHook,
  370.         LH_ExitFlush,    FALSE,
  371.     TAG_DONE))
  372.     {
  373.         struct Window *PanelWindow;
  374.  
  375.         LT_New(Handle,
  376.             LA_Type,    VERTICAL_KIND,
  377.         TAG_DONE);
  378.         {
  379.             LT_New(Handle,
  380.                 LA_Type,    VERTICAL_KIND,
  381.                 LA_LabelID,    MSG_V36_0083,
  382.             TAG_DONE);
  383.             {
  384.                 LT_New(Handle,
  385.                     LA_Type,    STRING_KIND,
  386.                     LA_LabelID,    MSG_HOTKEYPANEL_TERM_SCREEN_TO_FRONT_GAD,
  387.                     LA_STRPTR,    Hotkeys -> termScreenToFront,
  388.                     LA_Chars,    30,
  389.                     GTST_MaxChars,    255,
  390.                     LA_ID,        GAD_TERMTOFRONT,
  391.  
  392.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  393.                 TAG_DONE);
  394.  
  395.                 LT_New(Handle,
  396.                     LA_Type,    STRING_KIND,
  397.                     LA_LabelID,    MSG_HOTKEYPANEL_BUFFER_SCREEN_TO_FRONT_GAD,
  398.                     LA_STRPTR,    Hotkeys -> BufferScreenToFront,
  399.                     GTST_MaxChars,    255,
  400.                     LA_ID,        GAD_BUFFERTOFRONT,
  401.  
  402.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  403.                 TAG_DONE);
  404.  
  405.                 LT_New(Handle,
  406.                     LA_Type,    STRING_KIND,
  407.                     LA_LabelID,    MSG_HOTKEYPANEL_SKIP_DIAL_ENTRY_GAD,
  408.                     LA_STRPTR,    Hotkeys -> SkipDialEntry,
  409.                     GTST_MaxChars,    255,
  410.                     LA_ID,        GAD_SKIPDIAL,
  411.  
  412.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  413.                 TAG_DONE);
  414.  
  415.                 LT_New(Handle,
  416.                     LA_Type,    STRING_KIND,
  417.                     LA_LabelID,    MSG_HOTKEYPANEL_ABORT_AREXX_GAD,
  418.                     LA_STRPTR,    Hotkeys -> AbortARexx,
  419.                     GTST_MaxChars,    255,
  420.                     LA_ID,        GAD_ABORTAREXX,
  421.  
  422.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  423.                 TAG_DONE);
  424.  
  425.                 LT_EndGroup(Handle);
  426.             }
  427.  
  428.             LT_New(Handle,
  429.                 LA_Type,        VERTICAL_KIND,
  430.                 LA_LabelID,        MSG_V36_0084,
  431.             TAG_DONE);
  432.             {
  433.                 LT_New(Handle,
  434.                     LA_Type,        SliderType,
  435.                     LA_LabelID,        MSG_HOTKEYPANEL_COMMODITY_PRIORITY_GAD,
  436.                     LA_BYTE,        &Hotkeys -> CommodityPriority,
  437.                     GTSL_Min,        -128,
  438.                     GTSL_Max,        127,
  439.                     GTSL_LevelFormat,    "%4ld",
  440.                     LA_Chars,        16,
  441.                     LA_ID,            GAD_PRIORITY,
  442.                 TAG_DONE);
  443.  
  444.                 LT_New(Handle,
  445.                     LA_Type,    CHECKBOX_KIND,
  446.                     LA_LabelID,    MSG_HOTKEYPANEL_HOTKEYS_ENABLED_GAD,
  447.                     LA_BYTE,    &Hotkeys -> HotkeysEnabled,
  448.                     LA_ID,        GAD_HOTKEYS,
  449.                 TAG_DONE);
  450.  
  451.                 LT_EndGroup(Handle);
  452.             }
  453.  
  454.             LT_New(Handle,
  455.                 LA_Type,VERTICAL_KIND,
  456.             TAG_DONE);
  457.             {
  458.                 LT_New(Handle,
  459.                     LA_Type,    XBAR_KIND,
  460.                     LAXB_FullSize,    TRUE,
  461.                 TAG_DONE);
  462.  
  463.                 LT_EndGroup(Handle);
  464.             }
  465.  
  466.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  467.                 LAGR_SameSize,    TRUE,
  468.                 LAGR_Spread,    TRUE,
  469.             TAG_DONE);
  470.             {
  471.                 LT_New(Handle,
  472.                     LA_Type,    BUTTON_KIND,
  473.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  474.                     LA_ID,        GAD_USE,
  475.                     LABT_ReturnKey,    TRUE,
  476.                     LABT_ExtraFat,    TRUE,
  477.                 TAG_DONE);
  478.  
  479.                 LT_New(Handle,
  480.                     LA_Type,    BUTTON_KIND,
  481.                     LA_LabelID,    MSG_GLOBAL_LOAD_GAD,
  482.                     LA_ID,        GAD_LOAD,
  483.                     LABT_ExtraFat,    TRUE,
  484.                 TAG_DONE);
  485.  
  486.                 LT_New(Handle,
  487.                     LA_Type,    BUTTON_KIND,
  488.                     LA_LabelID,    MSG_GLOBAL_SAVE_GAD,
  489.                     LA_ID,        GAD_SAVE,
  490.                     LABT_ExtraFat,    TRUE,
  491.                 TAG_DONE);
  492.  
  493.                 LT_New(Handle,
  494.                     LA_Type,    BUTTON_KIND,
  495.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  496.                     LA_ID,        GAD_CANCEL,
  497.                     LABT_EscKey,    TRUE,
  498.                     LABT_ExtraFat,    TRUE,
  499.                 TAG_DONE);
  500.  
  501.                 LT_EndGroup(Handle);
  502.             }
  503.  
  504.             LT_EndGroup(Handle);
  505.         }
  506.  
  507.         if(PanelWindow = LT_Build(Handle,
  508.             LAWN_TitleID,        MSG_HOTKEYPANEL_HOTKEY_PREFERENCES_TXT,
  509.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  510.             LAWN_HelpHook,        &GuideHook,
  511.             LAWN_Parent,        Window,
  512.             WA_DepthGadget,        TRUE,
  513.             WA_CloseGadget,        TRUE,
  514.             WA_DragBar,        TRUE,
  515.             WA_RMBTrap,        TRUE,
  516.             WA_Activate,        TRUE,
  517.             WA_SimpleRefresh,    TRUE,
  518.         TAG_DONE))
  519.         {
  520.             struct IntuiMessage    *Message;
  521.             BOOLEAN             Done = FALSE;
  522.             ULONG             MsgClass;
  523.             struct Gadget        *MsgGadget;
  524.  
  525.             struct FileRequester    *FileRequest;
  526.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  527.                         *DummyChar;
  528.  
  529.             STRPTR             String;
  530.  
  531.             GuideContext(CONTEXT_HOTKEYS);
  532.  
  533.             PushWindow(PanelWindow);
  534.  
  535.             do
  536.             {
  537.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  538.                 {
  539.                     CopyMem(&PrivateHotkeys,Hotkeys,sizeof(struct Hotkeys));
  540.  
  541.                     break;
  542.                 }
  543.  
  544.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  545.                 {
  546.                     MsgClass    = Message -> Class;
  547.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  548.  
  549.                     LT_ReplyIMsg(Message);
  550.  
  551.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  552.                     {
  553.                         CopyMem(&PrivateHotkeys,Hotkeys,sizeof(struct Hotkeys));
  554.  
  555.                         Done = TRUE;
  556.                     }
  557.  
  558.                     if(MsgClass == IDCMP_GADGETUP)
  559.                     {
  560.                         switch(MsgGadget -> GadgetID)
  561.                         {
  562.                             case GAD_TERMTOFRONT:
  563.                             case GAD_BUFFERTOFRONT:
  564.                             case GAD_SKIPDIAL:
  565.                             case GAD_ABORTAREXX:
  566.  
  567.                                 String = LT_GetString(Handle,MsgGadget -> GadgetID);
  568.  
  569.                                 if(!GoodCode(String))
  570.                                 {
  571.                                     DisplayBeep(PanelWindow -> WScreen);
  572.  
  573.                                     LT_Activate(Handle,MsgGadget -> GadgetID);
  574.                                 }
  575.  
  576.                                 break;
  577.  
  578.                             case GAD_USE:
  579.  
  580.                                 LT_UpdateStrings(Handle);
  581.  
  582.                                 if(OldCRC != DoCRC(Hotkeys,sizeof(struct Hotkeys)))
  583.                                     HotkeysChanged = TRUE;
  584.  
  585.                                 Done = TRUE;
  586.                                 break;
  587.  
  588.                             case GAD_CANCEL:
  589.  
  590.                                 CopyMem(&PrivateHotkeys,Hotkeys,sizeof(struct Hotkeys));
  591.  
  592.                                 Done = TRUE;
  593.                                 break;
  594.  
  595.                             case GAD_LOAD:
  596.  
  597.                                 SplitFileName(LastKeys,&DummyChar,DummyBuffer);
  598.  
  599.                                 LT_LockWindow(PanelWindow);
  600.  
  601.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT),DummyBuffer,FilePart(LastKeys),DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  602.                                 {
  603.                                     if(!LoadHotkeys(DummyBuffer,Hotkeys))
  604.                                         ShowError(PanelWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  605.                                     else
  606.                                     {
  607.                                         strcpy(LastKeys,DummyBuffer);
  608.  
  609.                                         LT_SetAttributes(Handle,GAD_TERMTOFRONT,
  610.                                             GTST_String,Hotkeys -> termScreenToFront,
  611.                                         TAG_DONE);
  612.  
  613.                                         LT_SetAttributes(Handle,GAD_BUFFERTOFRONT,
  614.                                             GTST_String,Hotkeys -> BufferScreenToFront,
  615.                                         TAG_DONE);
  616.  
  617.                                         LT_SetAttributes(Handle,GAD_SKIPDIAL,
  618.                                             GTST_String,Hotkeys -> SkipDialEntry,
  619.                                         TAG_DONE);
  620.  
  621.                                         LT_SetAttributes(Handle,GAD_ABORTAREXX,
  622.                                             GTST_String,Hotkeys -> AbortARexx,
  623.                                         TAG_DONE);
  624.  
  625.                                         LT_SetAttributes(Handle,GAD_PRIORITY,
  626.                                             GTSL_Level,Hotkeys -> CommodityPriority,
  627.                                         TAG_DONE);
  628.  
  629.                                         LT_SetAttributes(Handle,GAD_HOTKEYS,
  630.                                             GTCB_Checked,Hotkeys -> HotkeysEnabled,
  631.                                         TAG_DONE);
  632.  
  633.                                         HotkeysChanged = FALSE;
  634.  
  635.                                         if(ChangePtr)
  636.                                             *ChangePtr = FALSE;
  637.                                     }
  638.  
  639.                                     FreeAslRequest(FileRequest);
  640.                                 }
  641.  
  642.                                 LT_UnlockWindow(PanelWindow);
  643.  
  644.                                 break;
  645.  
  646.                             case GAD_SAVE:
  647.  
  648.                                 LT_UpdateStrings(Handle);
  649.  
  650.                                 SplitFileName(LastKeys,&DummyChar,DummyBuffer);
  651.  
  652.                                 LT_LockWindow(PanelWindow);
  653.  
  654.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT),DummyBuffer,FilePart(LastKeys),DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  655.                                 {
  656.                                     if(!WriteIFFData(DummyBuffer,Hotkeys,sizeof(struct Hotkeys),ID_HOTK))
  657.                                         ShowError(PanelWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  658.                                     else
  659.                                     {
  660.                                         strcpy(LastKeys,DummyBuffer);
  661.  
  662.                                         HotkeysChanged = FALSE;
  663.  
  664.                                         if(ChangePtr)
  665.                                             *ChangePtr = FALSE;
  666.                                     }
  667.  
  668.                                     FreeAslRequest(FileRequest);
  669.                                 }
  670.  
  671.                                 LT_UnlockWindow(PanelWindow);
  672.  
  673.                                 break;
  674.                         }
  675.                     }
  676.                 }
  677.             }
  678.             while(!Done);
  679.  
  680.             PopWindow();
  681.         }
  682.  
  683.         LT_DeleteHandle(Handle);
  684.     }
  685.  
  686.     CloseLibrary(KeymapBase);
  687.  
  688.     if(ChangePtr)
  689.         *ChangePtr |= HotkeysChanged;
  690.  
  691.     return(HotkeysChanged);
  692. }
  693.